package lg.minecraft.plugin.entityclear.manager;

import lg.minecraft.plugin.entityclear.parser.EntityFilterParser;
import lg.minecraft.plugin.entityclear.parser.EntityRemoverParser;
import lg.minecraft.plugin.entityclear.parser.WorldFilterParser;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * 组件管理器，管理世界过滤器、实体过滤器和实体删除器
 *
 * @author langle__
 * @version 1.0
 */
public class ParserManager {

    public static final ParserManager INSTANCE = new ParserManager();

    private final Map<String, EntityFilterParser> entityFilterParserMap = new HashMap<>();
    private final Map<String, WorldFilterParser> worldFilterParserMap = new HashMap<>();
    private final Map<String, EntityRemoverParser> entityRemoverParserMap = new HashMap<>();

    private ParserManager() {}

    /**
     * 注册一个实体过滤器
     *
     * @param name   过滤器名称
     * @param filter 实体过滤器谓词
     */
    public void registerEntityFilterParser(@NotNull String name, @NotNull EntityFilterParser filter) {
        entityFilterParserMap.put(name.toLowerCase(), filter);
    }

    /**
     * 注册一个世界过滤器
     *
     * @param name   过滤器名称
     * @param filter 世界过滤器谓词
     */
    public void registerWorldFilterParser(@NotNull String name, @NotNull WorldFilterParser filter) {
        worldFilterParserMap.put(name.toLowerCase(), filter);
    }

    /**
     * 注册一个实体删除器
     *
     * @param name    删除器名称
     * @param remover 实体删除器
     */
    public void registerEntityRemoverParser(@NotNull String name, @NotNull EntityRemoverParser remover) {
        entityRemoverParserMap.put(name.toLowerCase(), remover);
    }

    /**
     * 移除一个实体过滤器
     *
     * @param name 过滤器名称
     * @return 如果成功移除返回true，否则返回false
     */
    public boolean removeEntityFilterParser(@NotNull String name) {
        return entityFilterParserMap.remove(name.toLowerCase()) != null;
    }

    /**
     * 移除一个世界过滤器
     *
     * @param name 过滤器名称
     * @return 如果成功移除返回true，否则返回false
     */
    public boolean removeWorldFilterParser(@NotNull String name) {
        return worldFilterParserMap.remove(name.toLowerCase()) != null;
    }

    /**
     * 移除一个实体删除器
     *
     * @param name 删除器名称
     * @return 如果成功移除返回true，否则返回false
     */
    public boolean removeEntityRemoverParser(@NotNull String name) {
        return entityRemoverParserMap.remove(name.toLowerCase()) != null;
    }

    /**
     * 获取指定名称的实体过滤器
     *
     * @param name 过滤器名称
     * @return 实体过滤器谓词，如果不存在返回null
     */
    @Nullable
    public EntityFilterParser getEntityFilterParser(@Nullable String name) {
        if (name == null || name.isEmpty()) return null;
        return entityFilterParserMap.get(name.toLowerCase());
    }

    /**
     * 获取指定名称的世界过滤器
     *
     * @param name 过滤器名称
     * @return 世界过滤器谓词，如果不存在返回null
     */
    @Nullable
    public WorldFilterParser getWorldFilterParser(@Nullable String name) {
        if (name == null || name.isEmpty()) return null;
        return worldFilterParserMap.get(name.toLowerCase());
    }

    /**
     * 获取指定名称的实体删除器
     *
     * @param name 删除器名称
     * @return 实体删除器，如果不存在返回null
     */
    @Nullable
    public EntityRemoverParser getEntityRemoverParser(@Nullable String name) {
        if (name == null || name.isEmpty()) return null;
        return entityRemoverParserMap.get(name.toLowerCase());
    }

    /**
     * 检查是否存在指定名称的实体过滤器
     *
     * @param name 过滤器名称
     * @return 如果存在返回true，否则返回false
     */
    public boolean containsEntityFilterParser(@NotNull String name) {
        return entityFilterParserMap.containsKey(name.toLowerCase());
    }

    /**
     * 检查是否存在指定名称的世界过滤器
     *
     * @param name 过滤器名称
     * @return 如果存在返回true，否则返回false
     */
    public boolean containsWorldFilterParser(@NotNull String name) {
        return worldFilterParserMap.containsKey(name.toLowerCase());
    }

    /**
     * 检查是否存在指定名称的实体删除器
     *
     * @param name 删除器名称
     * @return 如果存在返回true，否则返回false
     */
    public boolean containsEntityRemoverParser(@NotNull String name) {
        return entityRemoverParserMap.containsKey(name.toLowerCase());
    }

    /**
     * 获取所有实体过滤器名称
     *
     * @return 实体过滤器名称集合
     */
    @NotNull
    public Set<String> getEntityFilterParserNames() {
        return entityFilterParserMap.keySet();
    }

    /**
     * 获取所有世界过滤器名称
     *
     * @return 世界过滤器名称集合
     */
    @NotNull
    public Set<String> getWorldFilterParserNames() {
        return worldFilterParserMap.keySet();
    }

    /**
     * 获取所有实体删除器名称
     *
     * @return 实体删除器名称集合
     */
    @NotNull
    public Set<String> getEntityRemoverParserNames() {
        return entityRemoverParserMap.keySet();
    }

}
